(Numpy)¶In this project, I'm applying a variety of techniques and methods to put into practice the skills I've acquired in image processing and manipulation.
In this code snippet, we address the requirements necessary for a specific task, which involve installing a set of essential libraries. To successfully execute certain operations, these libraries need to be present within the working environment.
To achieve this, the code utilizes the subprocess module to execute commands in the system's shell. It begins by defining a list named required_libraries, which enumerates the libraries that are vital for the intended task.
The subsequent steps involve iterating through this list and, for each library, invoking the pip install command to install it. The subprocess.check_call() function facilitates the execution of shell commands.
By running this code, you can ensure that all the essential libraries are properly installed in the environment, enabling you to perform the desired operations seamlessly.
pip install subprocess
pip install tensorflow
import subprocess
# List of required libraries
required_libraries = [
'numpy',
'Pillow',
'IPython',
'opencv-python',
'dlib',
'avif-encode'
]
# Install the required libraries
for library in required_libraries:
subprocess.check_call(['pip', 'install', library])
Let's search for pictures of people to use in this project, and you can explore the following websites to find images:
The following code snippet is designed to facilitate the renaming of portrait images within a specified directory. The main purpose of this script is to organize and label portrait images in a consistent and sequential manner. The script scans through the given directory, identifies image files with extensions such as .jpg, .jpeg, .png, .gif, and .avif, and then renames them by prefixing them with "portrait_" followed by a unique sequential number.
Here's a brief overview of the code's functionality:
os module is imported to interact with the operating system.rename_images function is defined, taking a directory path as its argument.os.listdir(directory).os.path.join.os.rename function is used to perform the renaming operation.To use the code, replace image_directory with the path to the directory containing the portrait images you wish to rename. The script will then execute, sequentially renaming the images and providing informative output about the renaming process.
import os
def rename_images(directory):
# Get the list of files in the directory
files = os.listdir(directory)
# Filter only image files (you can modify this condition based on your image file extensions)
image_files = [file for file in files if file.endswith(('.jpg', '.jpeg', '.png', '.gif','.avif'))]
# Sort the image files to ensure consistent numbering
image_files.sort()
# Rename the image files with sequential numbers
for i, filename in enumerate(image_files, start=1):
new_filename = f"portrait_{i}{os.path.splitext(filename)[1]}"
old_path = os.path.join(directory, filename)
new_path = os.path.join(directory, new_filename)
os.rename(old_path, new_path)
print(f"Renamed {filename} to {new_filename}")
# Specify the directory where the images are located
image_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1'
# Call the function to rename the images
rename_images(image_directory)
Convert AVIF images to PNG format using a Python script with the avif library. Input AVIF file is decoded and transformed to RGB, then saved as PNG.
import avif
import os
def convert_avif_to_png(avif_path, png_path):
with open(avif_path, "rb") as f:
avif_data = f.read()
image = avif.Image.decode(avif_data)
rgb_image = image.to_rgb().to_image()
rgb_image.save(png_path, format="PNG")
print(f"Image converted: {avif_path} -> {png_path}")
# Specify the AVIF input file path
avif_file = "input.avif"
# Specify the PNG output file path
png_file = "output.png"
# Call the conversion function
convert_avif_to_png(avif_file, png_file)
this function takes a directory of images and the name of the function to run, and then applies the specified function to each image: python
To Specify the directory where the images are located: </br> image_directory = '/path/to/images' </br>
To Specify the name of the function to run (e.g., 'image_invertor', 'image_to_black_and_white', etc.): </br> function_name = 'image_invertor' </br>
To Call the function to apply the specified function to all images in the directory: </br> apply_image_function(image_directory, function_name) </br>
import os
def apply_image_function(directory, function_name):
# Get the list of files in the directory
files = os.listdir(directory)
# Filter only image files
image_files = [file for file in files if file.endswith(('.jpg', '.jpeg', '.png', '.gif', '.avif'))]
# Get the function to apply
selected_function = globals().get(function_name)
if selected_function is None:
print("Function not found.")
return
# Apply the selected function to each image
for file in image_files:
image_path = os.path.join(directory, file)
selected_function(image_path)
This Python function, "image_invertor," is part of the "Image Inverter" project. The function takes an image file as input, inverts its colors using numerical operations and numpy arrays, and displays the modified image. By applying this function, you can easily transform the colors of an image, creating interesting visual effects or exploring different perspectives. It utilizes popular libraries such as PIL and numpy for image manipulation and representation.
def image_invertor(image_dir):
import numpy as np
from PIL import Image
from IPython.display import display
# Open the image using the avif PIL plugin
image = Image.open(image_dir)
# Convert the AVIF image to RGB format
image = image.convert('RGB')
# Convert the image to a NumPy array
image_array = np.array(image)
# Apply color inversion
inverted_array = 255 - image_array
# Create a PIL image from the inverted array
inverted_image = Image.fromarray(inverted_array)
# Display the inverted image
display(inverted_image)
image_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\PNG'
function_name = 'image_invertor'
apply_image_function(image_directory, function_name)
This function, person_image_processor, is designed to process images of people to make them visually appealing. It uses the PIL library for image manipulation and the IPython.display library to display the modified image.
To use this function, you need to provide the file path of the image as the argument image_dir.
def person_image_processor(image_dir):
import numpy as np
from PIL import Image, ImageFilter, ImageEnhance
from IPython.display import display
# Open the image
image = Image.open(image_dir)
# Apply image processing operations
# Example: Convert the image to grayscale
grayscale_image = image.convert("L")
# Example: Apply a blur filter
# blurred_image = grayscale_image.filter(ImageFilter.BLUR)
# Example: Adjust the brightness
# enhanced_image = ImageEnhance.Brightness(image).enhance(1.5)
# Display the modified image
display(grayscale_image)
# example:
image_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\PNG'
function_name = 'person_image_processor'
apply_image_function(image_directory, function_name)
The goal of the provided Python code is to perform a technique known as "artistic style transfer" between a content image and a style image. Artistic style transfer is a deep learning-based approach that aims to merge the content of one image with the artistic style of another image. In other words, it allows you to apply the visual characteristics and artistic elements of a style image to a content image, resulting in a new image that combines the content of one image with the aesthetics of another.
import tensorflow as tf
import tensorflow_hub as hub
import numpy as np
from PIL import Image
def artistic_image_transform(content_image_path, style_image_path):
# Load the content and style images
content_image = tf.keras.preprocessing.image.load_img(content_image_path)
style_image = tf.keras.preprocessing.image.load_img(style_image_path)
# Preprocess the content and style images
content_image = tf.keras.preprocessing.image.img_to_array(content_image)
style_image = tf.keras.preprocessing.image.img_to_array(style_image)
content_image = content_image / 255.0
style_image = style_image / 255.0
# Define the model for style transfer
hub_module = hub.load('https://tfhub.dev/google/magenta/arbitrary-image-stylization-v1-256/2')
model = hub.KerasLayer(hub_module)
# Perform style transfer
stylized_image = model(tf.convert_to_tensor(content_image), tf.convert_to_tensor(style_image))[0]
# Convert the stylized image to PIL Image
stylized_image = np.array(stylized_image) * 255
stylized_image = stylized_image.astype(np.uint8)
stylized_image = Image.fromarray(stylized_image)
return stylized_image
# Specify the path of the content and style images
content_image_path = r'content.jpg'
style_image_path = r'style.jpg'
# Call the artistic_image_transform function
output_image = artistic_image_transform(content_image_path, style_image_path)
# Display the output image
output_image.show()
def image_to_black_and_white(image_dir):
from PIL import Image
from IPython.display import display
# Open the image
image = Image.open(image_dir)
# Convert the image to black and white
black_and_white_image = image.convert("L")
# Display the black and white image
display(black_and_white_image)
# example:
image_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\PNG'
function_name = 'image_to_black_and_white'
apply_image_function(image_directory, function_name)
The goal of the provided Python code is to convert a given input image into a vector representation using edge detection and contour extraction techniques, and then save the resulting vector representation as an SVG (Scalable Vector Graphics) file.
import cv2
import numpy as np
import svgwrite
def image_to_vector(image_path, output_path):
# Load the image
image = cv2.imread(image_path)
# Convert the image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Perform edge detection
edges = cv2.Canny(gray, 50, 150)
# Find contours in the edge-detected image
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# Create a new SVG drawing
dwg = svgwrite.Drawing(output_path + "/output.svg", profile='tiny')
# Draw the contours as vector paths
for contour in contours:
points = [(float(point[0][0]), float(point[0][1])) for point in contour]
dwg.add(dwg.polyline(points, fill='none', stroke='black'))
# Save the SVG file
dwg.save()
print("Vector image saved as:", output_path + "/output.svg")
# Example:
image_directory = r'R:\Downloads\download.jpg'
output_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\output_dir'
image_to_vector(image_directory, output_directory)
Vector image saved as: C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\output_dir/output.svg
convert a given input image into a cartoon-style image using a combination of image processing techniques, including grayscale conversion, edge detection, and filtering operations. The resulting cartoon-style image is then saved to the specified output directory.
def image_to_cartoon(image_dir, output_dir):
import cv2
import numpy as np
from PIL import Image
# Open the image
image = cv2.imread(image_dir)
# Convert the image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Apply a median blur to reduce noise
blurred = cv2.medianBlur(gray, 5)
# Perform edge detection
edges = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 9)
# Apply bilateral filter to smoothen the image
color = cv2.bilateralFilter(image, 9, 250, 250)
# Combine the edges and color image
cartoon = cv2.bitwise_and(color, color, mask=edges)
# Save the cartoon image
cartoon_path = output_dir + "/cartoon_image.jpg"
cv2.imwrite(cartoon_path, cartoon)
print("Cartoon image saved as:", cartoon_path)
# Example:
image_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\png\portrait_4.png'
output_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\output_dir'
image_to_cartoon(image_directory, output_directory)
Cartoon image saved as: C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\output_dir/cartoon_image.jpg
enhance the beauty of a given input image by applying a series of image processing operations, including bilateral filtering, contrast and brightness adjustment, and color correction. The resulting enhanced image is then saved to the specified output directory.
def enhance_beauty(image_dir, output_dir):
import cv2
import numpy as np
# Load the image
image = cv2.imread(image_dir)
# Apply bilateral filter to smooth the image while preserving edges
smoothed = cv2.bilateralFilter(image, 9, 75, 75)
# Increase contrast and brightness
enhanced = cv2.convertScaleAbs(smoothed, alpha=1.2, beta=10)
# Adjust skin tones using color correction
ycrcb = cv2.cvtColor(enhanced, cv2.COLOR_BGR2YCrCb)
channels = list(cv2.split(ycrcb))
channels[0] = cv2.equalizeHist(channels[0])
ycrcb = cv2.merge(channels)
corrected = cv2.cvtColor(ycrcb, cv2.COLOR_YCrCb2BGR)
# Save the enhanced image
enhanced_path = output_dir + "/enhanced_image.jpg"
cv2.imwrite(enhanced_path, corrected)
print("Enhanced image saved as:", enhanced_path)
# Example:
image_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\png\portrait_3.png'
output_directory = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\output_dir'
enhance_beauty(image_directory, output_directory)
Enhanced image saved as: C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\output_dir/enhanced_image.jpg
This function enhances the resolution of an input image using the Enhanced Deep Super-Resolution (EDSR) model. The EDSR model is a deep learning-based approach that utilizes advanced techniques to generate high-resolution versions of low-resolution images.
The function takes an image as input and applies the pre-trained EDSR model to perform super-resolution. It upscales the image to a higher resolution while preserving and enhancing the details and sharpness. The resulting super-resolved image exhibits improved clarity and quality, making it ideal for various applications, such as image enhancement, zooming, or printing.
To use the function, provide the path to the input image and ensure the availability of the EDSR model file. The function leverages the TensorFlow library to load the model and applies it to the image. The output is a super-resolved image that is displayed or can be saved for further use.
In this alternative approach, the function uses the OpenCV library to load the low-resolution image and perform super-resolution. The function converts the image to the YCrCb color space, extracts the Y channel (luma component), and upscales it using bilinear interpolation (cv2.resize) to achieve a 2x super-resolution.
The function then combines the super-resolved Y channel with the original Cr and Cb channels to form the super-resolved image in the YCrCb color space. Finally, it converts the super-resolved image back to the BGR color space for display purposes.
import cv2
import numpy as np
import tensorflow as tf
import tensorflow_hub as hub
def image_super_resolution(image_path):
# Load the low-resolution image using OpenCV
lr_image = cv2.imread(image_path)
# Convert the image from BGR to RGB
lr_image_rgb = cv2.cvtColor(lr_image, cv2.COLOR_BGR2RGB)
# Convert the image to float32 and normalize pixel values
lr_image_float = lr_image_rgb.astype(np.float32) / 255.0
# Load the ESRGAN generator model from TensorFlow Hub
model = hub.load("https://tfhub.dev/captain-pool/esrgan-tf2/1")
# Reshape the low-resolution image to match the model input shape
lr_input = tf.expand_dims(lr_image_float, axis=0)
# Generate the super-resolved image
sr_output = model(lr_input)[0]
# Rescale the output image pixel values to [0, 255]
sr_output = ((sr_output + 1) / 2.0) * 255.0
# Convert the image to uint8
sr_image_rgb = sr_output.numpy().astype(np.uint8)
# Convert the image from RGB to BGR
sr_image_bgr = cv2.cvtColor(sr_image_rgb, cv2.COLOR_RGB2BGR)
return sr_image_bgr
# Specify the path of the input image
input_image_path = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\low_res_images\portrait_low_res_3.jpg'
# Call the image_super_resolution function
output_image = image_super_resolution(input_image_path)
# Display the output image
cv2.imshow('Output Image', output_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
import tensorflow as tf
from PIL import Image
def image_super_resolution(image_path):
# Load the pre-trained EDSR model
model = tf.keras.models.load_model(r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\ML_pre_trained_models\EDSR_Tensorflow-master\models\EDSR_x2.pb')
# Load and preprocess the input image
image = tf.keras.preprocessing.image.load_img(image_path, target_size=(64, 64))
image = tf.keras.preprocessing.image.img_to_array(image)
image = image.astype('float32') / 255.0
# Perform image super-resolution
super_res_image = model.predict(tf.expand_dims(image, axis=0))[0]
# Rescale the super-resolved image to 0-255 range
super_res_image = tf.clip_by_value(super_res_image, 0.0, 1.0)
super_res_image = tf.round(super_res_image * 255.0)
super_res_image = tf.cast(super_res_image, tf.uint8)
# Convert the super-resolved image to PIL Image
super_res_image = tf.keras.preprocessing.image.array_to_img(super_res_image)
return super_res_image
# Specify the path of the input image
input_image_path = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\images\course1_1\low_res_images\portrait_low_res_1'
# input_model_path = r'C:\Users\User\Desktop\GitHub-projects\projects\Data-Dives-Projects-Unleashed\ML_pre_trained_models\EDSR_Tensorflow-master\models\EDSR_x4.pb'
# Call the image_super_resolution function
output_image = image_super_resolution(input_image_path)
# Display the output image
output_image.show()
In the journey of exploring the realm of image manipulation, I've embarked on a fascinating and creative path that has allowed me to delve into the captivating world of image manipulation. Through this project, I've had the opportunity to experiment with various techniques and tools that breathe new life into ordinary visuals, elevating them into something extraordinary.